<html>
	<head>
		<title>Newton Game Dynamics DBPro Wrapper v1.53</title></head>
	<body alink="#fa634e" bgcolor="#efeff9" link="#3646fc" text="#000000" vlink="#ff6633">
		<H1>Newton SDK DBPro Wrapper v1.53</H1>
		<P>By Walaber<BR>
		   All Coding between 1.31-1.32B by Kjelle<BR>
		   Updated to 1.53 by Tiresius</P>
        <p><a href="ndb_docs_main.htm">Main Index of Commands</a></p>
		<h2>Convex Collision Primitives Interface Commands</h2>
		<p><a name="NDB_NewtonCreateNull"></a></p>
		<table cellspacing="0" bordercolorlight="#0506a5" bordercolordark="#0506a5" bgcolor="#ffffff"
			border="1" width="85%">
			<tr>
				<td bgcolor="#232323">
					<h3><font color="#fafafa">NDB_NewtonCreateNull</font></h3>
				</td>
			</tr>
			<tr>
				<td bgcolor="#747ff6"><font color="#ffffff" face="monospace">syntax: int =
						NDB_NewtonCreateNull()</font></td>
			</tr>
			<tr>
				<td bgcolor="#fafafa"><font face="monospace">
						<table border="0" width="95%">
							<tr>
								<td width="5%"></td>
								<td width="50%">no variables passed to this function.</td>
								<td></td>
							</tr>
						</table>
					</font>
				</td>
			</tr>
			<tr>
				<td bgcolor="#dadada"><font face="monospace">returns: integer index to the collision
						data created.</font></td>
			</tr>
			<tr>
				<td bgcolor="#fafafa">
					<p><b>Comments: </b>Makes a null collision object. &nbsp;Null objects will never
						colide with anything, but exist for special cases when you need a "space
						filler".
					</p>
				</td>
			</tr>
			<tr>
				<td bgcolor="#fafafa">
					<font face="monospace"><b>col = NDB_NewtonCreateNull()</b></font> make null
					collision data, and store the index to it in the variable "col"</td>
			</tr>
		</table>
		<p>&nbsp;</p>
		<a name="NDB_NewtonCreateSphere"></a>
		<table cellspacing="0" bordercolorlight="#0506a5" bordercolordark="#0506a5" bgcolor="#ffffff"
			border="1" width="85%">
			<tbody>
				<tr>
					<td bgcolor="#232323"><h3><font color="#fafafa">NDB_NewtonCreateSphere</font></h3>
					</td>
				</tr>
				<tr>
					<td bgcolor="#747ff6"><font color="#ffffff" face="monospace">syntax: int =
							NDB_NewtonCreateSphere( rad [ ,matrix_flag ] )</font></td>
				</tr>
				<tr>
					<td bgcolor="#fafafa"><font face="monospace">
							<table border="0" width="95%">
								<tbody>
									<tr>
										<td width="5%"></td>
										<td width="15%">radius</td>
										<td>radius of the sphere (float)</td>
									</tr>
									<tr>
										<td width="5%"></td>
										<td width="15%">matrix_flag</td>
										<td>flag whether or not to use offset matrix. 1 = use matrix *optional</td>
									</tr>
								</tbody></table>
						</font>
					</td>
				</tr>
				<tr>
					<td bgcolor="#dadada"><font face="monospace">returns: integer index to the collision
							data created.</font></td>
				</tr>
				<tr>
					<td bgcolor="#fafafa"><b>Comments:</b>Newton rigid bodies are made from collision
						data. The simplest way to make collision data is to use the built-in
						primitives. If you want the collision data offset from the origin of the body,
						set the data into the temp matrix, and then add a ",1" flag to the command. No
						flag assumes the collision data will be centered at the origin of the body.</td>
				</tr>
				<tr>
					<td bgcolor="#fafafa">
						<font face="monospace"><b>col = NDB_NewtonCreateSphere( 2.0 )</b></font> make
						collision data of a sphere with radius 2.0, and store the index to it in the
						variable "col"
					</td>
				</tr>
			</tbody></table>
		<p>
			<a name="NDB_NewtonCreateBox"></a>
			<table cellspacing="0" bordercolorlight="#0506a5" bordercolordark="#0506a5" bgcolor="#ffffff"
				border="1" width="85%">
				<tbody>
					<tr>
						<td bgcolor="#232323"><h3><font color="#fafafa">NDB_NewtonCreateBox</font></h3>
						</td>
					</tr>
					<tr>
						<td bgcolor="#747ff6"><font color="#ffffff" face="monospace">syntax: col =
								NDB_NewtonCreateBox( [x, y, z, matrix_flag] )</font></td>
					</tr>
					<tr>
						<td bgcolor="#fafafa"><font face="monospace">
								<table border="0" width="95%">
									<tbody>
										<tr>
											<td width="5%"></td>
											<td width="15%">x</td>
											<td>X size of the box (float) *optional</td>
										</tr>
										<tr>
											<td width="5%"></td>
											<td width="15%">y</td>
											<td>Y size of the box (float) *optional</td>
										</tr>
										<tr>
											<td width="5%"></td>
											<td width="15%">z</td>
											<td>Z size of the box (float) *optional</td>
										</tr>
										<tr>
											<td width="5%"></td>
											<td width="15%">matrix_flag</td>
											<td>flag whether or not to use offset matrix. 1 = use matrix *optional</td>
										</tr>
									</tbody></table>
							</font>
						</td>
					</tr>
					<tr>
						<td bgcolor="#dadada"><font face="monospace">returns: integer index to the collision
								data created.</font></td>
					</tr>
					<tr>
						<td bgcolor="#fafafa"><b>Comments:</b> Makes collision data of a simple box. If you
							don't supply the x,y,z values, the wrapper automatically uses the contents of <b>temp
								vector 1</b>. If you want the collision data offset from the origin of the
							body, set the data into the temp matrix, and then add a ",1" flag to the
							command. No flag assumes the collision data will be centered at the origin of
							the body.</td>
					</tr>
					<tr>
						<td bgcolor="#fafafa">
							<font face="monospace"><b>col = NDB_NewtonCreateBox( 10.0, 2.0, 2.0 )</b></font>
							create collision data of a box with dimensions x=10 y=2 z=2 centered on the
							origin.<br>
							<font face="monospace"><b>col = NDB_NewtonCreateBox( 1 )</b></font> create
							collision data of a box with dimensions stored in temp vector 1, and offset
							based on contents of temp matrix.
						</td>
					</tr>
				</tbody></table>
		<p><a name="NDB_NewtonCreateCylinder"></a></p>
		<table cellspacing="0" bordercolorlight="#0506a5" bordercolordark="#0506a5" bgcolor="#ffffff"
			border="1" width="85%">
			<tr>
				<td bgcolor="#232323">
					<h3><font color="#fafafa">NDB_NewtonCreateCylinder</font></h3>
				</td>
			</tr>
			<tr>
				<td bgcolor="#747ff6"><font color="#ffffff" face="monospace">syntax: int =
						NDB_NewtonCreateCylinder( rad,&nbsp;height [ ,matrix_flag ] )</font></td>
			</tr>
			<tr>
				<td bgcolor="#fafafa"><font face="monospace">
						<table border="0" width="95%">
							<tbody>
								<tr>
									<td width="5%"></td>
									<td width="15%">rad</td>
									<td>radius of the cylinder&nbsp;(float)</td>
								</tr>
								<tr>
									<td width="5%"></td>
									<td width="15%">height</td>
									<td>height of the cylinder (float)</td>
								</tr>
							</tbody>
							<tr>
								<td width="5%">&nbsp;</td>
								<td width="15%">matrix_flag</td>
								<td>flag whether or not to use offset matrix. 1 = use matrix *optional</td>
							</tr>
						</table>
					</font>
				</td>
			</tr>
			<tr>
				<td bgcolor="#dadada"><font face="monospace">returns: integer index to the collision
						data created.</font></td>
			</tr>
			<tr>
				<td bgcolor="#fafafa">
					<p><b>Comments:</b>Makes a primitive cylinder object. Cylinders are by default
						aligned with the height along the x-axis. Call this function with a flag of
						",1" to apply an offset matrix to the collision data.
					</p>
				</td>
			</tr>
			<tr>
				<td bgcolor="#fafafa">
					<font face="monospace"><b>col = NDB_NewtonCreateCylinder( 2.0,&nbsp;5.0 )</b></font>
					make collision data of a cylinder&nbsp;with radius 2.0 height 5.0, and store
					the index to it in the variable "col"</td>
			</tr>
		</table>
		<p><a name="NDB_NewtonCreateChamferCylinder"></a></p>
		<table cellspacing="0" bordercolorlight="#0506a5" bordercolordark="#0506a5" bgcolor="#ffffff"
			border="1" width="85%">
			<tr>
				<td bgcolor="#232323">
					<h3><font color="#fafafa">NDB_NewtonCreateChamferCylinder</font></h3>
				</td>
			</tr>
			<tr>
				<td bgcolor="#747ff6"><font color="#ffffff" face="monospace">syntax: int =
						NDB_NewtonCreateChamferCylinder( rad,&nbsp;height [ ,matrix_flag ] )</font></td>
			</tr>
			<tr>
				<td bgcolor="#fafafa"><font face="monospace">
						<table border="0" width="95%">
							<tbody>
								<tr>
									<td width="5%"></td>
									<td width="15%">rad</td>
									<td>radius of the cylinder&nbsp;(float)</td>
								</tr>
								<tr>
									<td width="5%"></td>
									<td width="15%">height</td>
									<td>height of the cylinder (float)</td>
								</tr>
							</tbody>
							<tr>
								<td width="5%">&nbsp;</td>
								<td width="15%">matrix_flag</td>
								<td>flag whether or not to use offset matrix. 1 = use matrix *optional</td>
							</tr>
						</table>
					</font>
				</td>
			</tr>
			<tr>
				<td bgcolor="#dadada"><font face="monospace">returns: integer index to the collision
						data created.</font></td>
			</tr>
			<tr>
				<td bgcolor="#fafafa">
					<p><b>Comments:</b>Makes a primitive chamfer cylinder object. Chamfer Cylinders are
						by default aligned with the height along the x-axis. Call this function with a
						flag of ",1" to apply an offset matrix to the collision data.
					</p>
				</td>
			</tr>
			<tr>
				<td bgcolor="#fafafa">
					<font face="monospace"><b>col = NDB_NewtonCreateChamferCylinder( 2.0,&nbsp;5.0 )</b></font>
					make collision data of a chamfer cylinder&nbsp;with radius 2.0 height 5.0, and
					store the index to it in the variable "col"</td>
			</tr>
		</table>
		<p>&nbsp;</p>
		<p><a name="NDB_NewtonCreateCapsule"></a></p>
		<table cellspacing="0" bordercolorlight="#0506a5" bordercolordark="#0506a5" bgcolor="#ffffff"
			border="1" width="85%">
			<tr>
				<td bgcolor="#232323">
					<h3><font color="#fafafa">NDB_NewtonCreateCapsule</font></h3>
				</td>
			</tr>
			<tr>
				<td bgcolor="#747ff6"><font color="#ffffff" face="monospace">syntax: int =
						NDB_NewtonCreateCapsule( rad,&nbsp;height [ ,matrix_flag ] )</font></td>
			</tr>
			<tr>
				<td bgcolor="#fafafa"><font face="monospace">
						<table border="0" width="95%">
							<tbody>
								<tr>
									<td width="5%"></td>
									<td width="15%">rad</td>
									<td>radius of the capsule&nbsp;(float)</td>
								</tr>
								<tr>
									<td width="5%"></td>
									<td width="15%">height</td>
									<td>height of the capsule (float)</td>
								</tr>
							</tbody>
							<tr>
								<td width="5%">&nbsp;</td>
								<td width="15%">matrix_flag</td>
								<td>flag whether or not to use offset matrix. 1 = use matrix *optional</td>
							</tr>
						</table>
					</font>
				</td>
			</tr>
			<tr>
				<td bgcolor="#dadada"><font face="monospace">returns: integer index to the collision
						data created.</font></td>
			</tr>
			<tr>
				<td bgcolor="#fafafa">
					<p><b>Comments:</b>Makes a primitive capsule&nbsp;object. Capsules are by default
						aligned with the height along the x-axis. Call this function with a flag of
						",1" to apply an offset matrix to the collision data.
					</p>
				</td>
			</tr>
			<tr>
				<td bgcolor="#fafafa">
					<font face="monospace"><b>col = NDB_NewtonCreateCapsule( 2.0,&nbsp;5.0 )</b></font>
					make collision data of a capsule&nbsp;with radius 2.0 height 5.0, and store the
					index to it in the variable "col"</td>
			</tr>
		</table>
		<p><a name="NDB_NewtonCreateCone"></a></p>
		<table cellspacing="0" bordercolorlight="#0506a5" bordercolordark="#0506a5" bgcolor="#ffffff"
			border="1" width="85%">
			<tr>
				<td bgcolor="#232323">
					<h3><font color="#fafafa">NDB_NewtonCreateCone</font></h3>
				</td>
			</tr>
			<tr>
				<td bgcolor="#747ff6"><font color="#ffffff" face="monospace">syntax: int =
						NDB_NewtonCreateCone( rad,&nbsp;height [ ,matrix_flag ] )</font></td>
			</tr>
			<tr>
				<td bgcolor="#fafafa"><font face="monospace">
						<table border="0" width="95%">
							<tbody>
								<tr>
									<td width="5%"></td>
									<td width="15%">rad</td>
									<td>radius of the cone&nbsp;(float)</td>
								</tr>
								<tr>
									<td width="5%"></td>
									<td width="15%">height</td>
									<td>height of the cone&nbsp;(float)</td>
								</tr>
							</tbody>
							<tr>
								<td width="5%">&nbsp;</td>
								<td width="15%">matrix_flag</td>
								<td>flag whether or not to use offset matrix. 1 = use matrix *optional</td>
							</tr>
						</table>
					</font>
				</td>
			</tr>
			<tr>
				<td bgcolor="#dadada"><font face="monospace">returns: integer index to the collision
						data created.</font></td>
			</tr>
			<tr>
				<td bgcolor="#fafafa">
					<p><b>Comments:</b>Makes a primitive cone&nbsp;object. Cones are by default aligned
						with the height along the x-axis. Call this function with a flag of ",1" to
						apply an offset matrix to the collision data.
					</p>
				</td>
			</tr>
			<tr>
				<td bgcolor="#fafafa">
					<font face="monospace"><b>col = NDB_NewtonCreateCone(12.0,&nbsp;3.0 )</b></font>
					make collision data of a capsule&nbsp;with radius 12.0 height 3.0, and store
					the index to it in the variable "col"</td>
			</tr>
		</table>
		<p><a name="NDB_NewtonCreateConvexHull"></a></p>
		<table cellspacing="0" bordercolorlight="#0506a5" bordercolordark="#0506a5" bgcolor="#ffffff"
			border="1" width="85%">
			<tr>
				<td bgcolor="#232323">
					<h3><font color="#fafafa">NDB_NewtonCreateConvexHull</font></h3>
				</td>
			</tr>
			<tr>
				<td bgcolor="#747ff6"><font color="#ffffff" face="monospace">syntax: int =
						NDB_NewtonCreateConvexHull( obj_num&nbsp;[ ,matrix_flag ] )</font></td>
			</tr>
			<tr>
				<td bgcolor="#fafafa"><font face="monospace">
						<table border="0" width="95%">
							<tbody>
								<tr>
									<td width="5%"></td>
									<td width="15%">obj_num</td>
									<td>object to use for convex hull data (integer)</td>
								</tr>
							</tbody>
							<tr>
								<td width="5%">&nbsp;</td>
								<td width="15%">matrix_flag</td>
								<td>flag whether or not to use offset matrix. 1 = use matrix *optional</td>
							</tr>
						</table>
					</font>
				</td>
			</tr>
			<tr>
				<td bgcolor="#dadada"><font face="monospace">returns: integer index to the collision
						data created.</font></td>
			</tr>
			<tr>
				<td bgcolor="#fafafa">
					<p><b>Comments: </b>Makes a convex hull primitive. &nbsp;Convex Hulls take a set of
						vertices, and "wrap" it, making the smallest possible convex shape that
						includes all of the vertices. &nbsp;Imagine wrapping an odd-shaped item in
						&nbsp;wrapping paper, and that's basically what it does. &nbsp;This command
						uses all of the vertices in the supplied object to create the collision.
					</p>
				</td>
			</tr>
			<tr>
				<td bgcolor="#fafafa">
					<p><font face="monospace"><b>load object "boulder.x", 10<br>
								col = NDB_NewtonCreateConvexHull( 10 )</b></font> make collision data from
						vertice data of object 10, and store the index to it in the variable "col"</p>
				</td>
			</tr>
		</table>
		<p>&nbsp;</p>
		<p>
			<a name="NDB_NewtonCreateCompoundCollision"></a>
			<table cellspacing="0" bordercolorlight="#0506a5" bordercolordark="#0506a5" bgcolor="#ffffff"
				border="1" width="85%">
				<tbody>
					<tr>
						<td bgcolor="#232323"><h3><font color="#fafafa">NDB_NewtonCreateCompoundCollision</font></h3>
						</td>
					</tr>
					<tr>
						<td bgcolor="#747ff6"><font color="#ffffff" face="monospace">syntax: col =
								NDB_NewtonCreateCompoundCollision</font></td>
					</tr>
					<tr>
						<td bgcolor="#fafafa"><font face="monospace">
								<table border="0" width="95%">
									<tbody>
										<tr>
											<td width="5%"></td>
											<td width="50%">no variables passed to this function.</td>
											<td></td>
										</tr>
									</tbody></table>
							</font>
						</td>
					</tr>
					<tr>
						<td bgcolor="#dadada"><font face="monospace">returns: integer index to the collision
								data created.</font></td>
					</tr>
					<tr>
						<td bgcolor="#fafafa"><b>Comments:</b> Compound Collision is collision data based
							on several collision primitives. For example using 4 box primitives to
							represent a picture frame.<br>
							<b>CAUTION</b> you MUST follow the following step to make compound collion
							data:<br>
							call the function <a href="#NDB_StartCompoundCollision">NDB_StartCompoundCollision</a>.<br>
							Then, for each primitive:<ul>
								<li>
									make the primitive in the usual manner <i>with an offset matrix</i>.
								<li>
									call the function <a href="#NDB_AddCollisionToArray#">NDB_AddCollisionToArray</a>
									to add the collision to the list.</li>
							</ul>
							call the <b>NDB_NewtonCreateCompoundCollision</b> function to get a reference
							to the compound collision.<br>
							Make your rigid body as normal with the <a href="#NDB_NewtonCreateBody">NDB_NewtonCreateBody</a>
							command.</td>
					</tr>
				</tbody></table>
		<p><a name="NDB_StartCompoundCollision"></a></p>
		<table cellspacing="0" bordercolorlight="#0506a5" bordercolordark="#0506a5" bgcolor="#ffffff"
			border="1" width="85%">
			<tr>
				<td bgcolor="#232323">
					<h3><font color="#fafafa">NDB_StartCompoundCollision</font></h3>
				</td>
			</tr>
			<tr>
				<td bgcolor="#747ff6"><font color="#ffffff" face="monospace">syntax:
						NDB_StartCompoundCollision</font></td>
			</tr>
			<tr>
				<td bgcolor="#fafafa"><font face="monospace">
						<table border="0" width="95%">
							<tr>
								<td width="5%"></td>
								<td width="50%">no variables passed to this function</td>
								<td></td>
							</tr>
						</table>
					</font>
				</td>
			</tr>
			<tr>
				<td bgcolor="#dadada"><font face="monospace">returns: nothing.</font></td>
			</tr>
			<tr>
				<td bgcolor="#fafafa">
					<p><b>Comments:</b> This command clears the wrapper's internal array of Newton
						Collision objects, for creating CompoundCollision objects. you must call this
						command before starting a new compound collision object. To add collisions to
						the array, use the <a href="#NDB_AddCollisionToArray">NDB_AddCollisionToArray</a>
						command. .
					</p>
				</td>
			</tr>
		</table>
		<p><a name="NDB_AddCollisionToArray"></a></p>
		<table cellspacing="0" bordercolorlight="#0506a5" bordercolordark="#0506a5" bgcolor="#ffffff"
			border="1" width="85%">
			<tr>
				<td bgcolor="#232323">
					<h3><font color="#fafafa">NDB_AddCollisionToArray</font></h3>
				</td>
			</tr>
			<tr>
				<td bgcolor="#747ff6"><font color="#ffffff" face="monospace">syntax:
						NDB_AddCollisionToArray col</font></td>
			</tr>
			<tr>
				<td bgcolor="#fafafa"><font face="monospace">
						<table border="0" width="95%">
							<tr>
								<td width="5%"></td>
								<td width="15%">col</td>
								<td>
									<p>index of collision data to add (integer)</p>
								</td>
							</tr>
						</table>
					</font>
				</td>
			</tr>
			<tr>
				<td bgcolor="#dadada"><font face="monospace">returns: nothing.</font></td>
			</tr>
			<tr>
				<td bgcolor="#fafafa">
					<p><b>Comments:</b> This command adds the supplied Newton Collision data into the
						next slot in the collision array, for creating CompoundCollision objects. After
						adding all collision objects to the array, call the <a href="#NDB_NewtonCreateCompoundCollision">
							NDB_NewtonCreateCompoundCollision</a>. Before adding the first collision to
						the array, make sure you call the <a href="#NDB_StartCompoundCollision">NDB_StartCollisionArray</a>
						command.
					</p>
				</td>
			</tr>
		</table>
		<p>&nbsp;</p>
		<p>
			<a name="NDB_NewtonCreateTreeCollision"></a>
			<table cellspacing="0" bordercolorlight="#0506a5" bordercolordark="#0506a5" bgcolor="#ffffff"
				border="1" width="85%">
				<tbody>
					<tr>
						<td bgcolor="#232323"><h3><font color="#fafafa">NDB_NewtonCreateTreeCollision</font></h3>
						</td>
					</tr>
					<tr>
						<td bgcolor="#747ff6"><font color="#ffffff" face="monospace">syntax: col =
								NDB_NewtonCreateTreeCollision( [db_num, limb flag] )</font></td>
					</tr>
					<tr>
						<td bgcolor="#fafafa"><font face="monospace">
								<table border="0" width="95%">
									<tbody>
										<tr>
											<td width="5%"></td>
											<td width="15%">db_num</td>
											<td>dbpro object number of the object to turn into collision data.</td>
										</tr>
										<tr>
											<td width="5%">&nbsp;</td>
											<td width="15%">flag</td>
											<td>optional method flag. &nbsp;1 = limb-by-limb method for high poly objects.</td>
										</tr>
									</tbody></table>
							</font>
						</td>
					</tr>
					<tr>
						<td bgcolor="#dadada"><font face="monospace">returns: integer index to the collision
								data created.</font></td>
					</tr>
					<tr>
						<td bgcolor="#fafafa">
							<P><b>Comments:</b> Newton supports mesh-based collision. However objects made from
								mesh collision automatically have infinite mass, making them immobile. These
								objects are good for backgrounds, terrains, buildings, etc.
							</P>
							<P>
								<br>
								<b>WAYS TO USE THIS COMMAND:</b><br>
								<br>
								<i><b>with existing dbpro object</b></i>: &nbsp;<br>
								Call this command with the object number, and a tree collision will be made
								from that object's polygon data. &nbsp;For very high-poly objects (like
								advanced terrain objects, etc), this command may fail. &nbsp;In that case, add
								flag of "1" to specify a limb-by-limb method, which should work for most
								high-poly objects.<br>
								<br>
								<i><b>for other data</b></i>:
								<br>
								Call this command with NO variables to start a manual Tree Collision object.
								&nbsp;Then use the <a href="#NDB_NewtonTreeCollisionBeginBuild">NDB_NewtonTreeCollisionBeginBuild</a>,
								<a href="#NDB_NewtonTreeCollisionAddFace">NDB_NewtonTreeCollisionAddFace</a>, <a href="#NDB_NewtonTreeCollisionEndBuild">
									NDB_NewtonTreeCollisionEndBuild</a> commands to add polygon data to the
								Tree Collision.<br>
								<br>
								<br>
								<b>NOTE</b> when calling with a dbpro object, this command uses DBPro memblock
								and mesh commands <i>internally</i>. If you don't have any memblock or mesh
								commands in your program, DBPRO will NOT include the dll's for these commands
								in your final program exe. This will cause the program to crash when it tries
								to make the Tree Collision. The solution to this problem, is to put a few
								commands down at the botton of your progam (or somewhere they will never
								actually be called) to FORCE dbpro to include the memblock and mesh command
								dlls. You might use something like this:<br>
								<br>
								if memblock exist(1) then end<br>
								if mesh exist(1) then end<br>
								...down at the bottom of your program.
							</P>
						</td>
					</tr>
					<tr>
						<td bgcolor="#fafafa">
							<font face="monospace"><b>load object "terrain.x", 100</b></font> load an
							object like normal.<br>
							<font face="monospace"><b>col = NDB_NewtonCreateTreeCollision( 100 )</b></font>
							make collision data based on this object's polygon data.
						</td>
					</tr>
				</tbody></table>
		<p>
			<a name="NDB_NewtonCreateTreeCollisionUnOptimized"></a>
			<table cellspacing="0" bordercolorlight="#0506a5" bordercolordark="#0506a5" bgcolor="#ffffff"
				border="1" width="85%" ID="Table17">
				<tbody>
					<tr>
						<td bgcolor="#232323"><h3><font color="#fafafa">NDB_NewtonCreateTreeCollisionUnOptimized</font></h3>
						</td>
					</tr>
					<tr>
						<td bgcolor="#747ff6"><font color="#ffffff" face="monospace">syntax: col =
								NDB_NewtonCreateTreeCollisionUnOptimized( [db_num, limb flag] )</font></td>
					</tr>
					<tr>
						<td bgcolor="#fafafa"><font face="monospace">
								<table border="0" width="95%" ID="Table18">
									<tbody>
										<tr>
											<td width="5%"></td>
											<td width="15%">db_num</td>
											<td>dbpro object number of the object to turn into collision data.</td>
										</tr>
										<tr>
											<td width="5%">&nbsp;</td>
											<td width="15%">flag</td>
											<td>optional method flag. &nbsp;1 = limb-by-limb method for high poly objects.</td>
										</tr>
									</tbody></table>
							</font>
						</td>
					</tr>
					<tr>
						<td bgcolor="#dadada"><font face="monospace">returns: integer index to the collision
								data created.</font></td>
					</tr>
					<tr>
						<td bgcolor="#fafafa">
							<p><b>Comments:</b> Same as above but no Optimization.
							</p>
						</td>
					</tr>
				</tbody></table>
		<p><a name="NDB_NewtonTreeCollisionBeginBuild"></a></p>
		<table cellspacing="0" bordercolorlight="#0506a5" bordercolordark="#0506a5" bgcolor="#ffffff"
			border="1" width="85%">
			<tbody>
				<tr>
					<td bgcolor="#232323">
						<h3><font color="#fafafa">NDB_NewtonTreeCollisionBeginBuild</font></h3>
					</td>
				</tr>
				<tr>
					<td bgcolor="#747ff6"><font color="#ffffff" face="monospace">syntax:
							NDB_NewtonTreeCollisionBeginBuild col</font></td>
				</tr>
				<tr>
					<td bgcolor="#fafafa"><font face="monospace">
							<table border="0" width="95%">
								<tbody>
									<tr>
										<td width="5%"></td>
										<td width="15%">col</td>
										<td>collision data index returned in NDB_NewtonCreateTreeCollision command.</td>
									</tr>
								</tbody></table>
						</font>
					</td>
				</tr>
				<tr>
					<td bgcolor="#dadada"><font face="monospace">returns: nothing.</font></td>
				</tr>
				<tr>
					<td bgcolor="#fafafa">
						<p><b>Comments:</b> This command tells Newton you are about to add faces (polygon
							data) to an empty Tree Collision object. &nbsp;To use this manual method you
							must have created an empty TreeCollision object by calling <a href="#NDB_NewtonCreateTreeCollision">
								NDB_NewtonCreateTreeCollision</a> with no parameters.</p>
					</td>
				</tr>
			</tbody></table>
		<p><a name="NDB_NewtonTreeCollisionAddFace"></a></p>
		<table cellspacing="0" bordercolorlight="#0506a5" bordercolordark="#0506a5" bgcolor="#ffffff"
			border="1" width="85%">
			<tbody>
				<tr>
					<td bgcolor="#232323">
						<h3><font color="#fafafa">NDB_NewtonTreeCollisionAddFace</font></h3>
					</td>
				</tr>
				<tr>
					<td bgcolor="#747ff6"><font color="#ffffff" face="monospace">syntax:
							NDB_NewtonTreeCollisionAddFace col</font></td>
				</tr>
				<tr>
					<td bgcolor="#fafafa"><font face="monospace">
							<table border="0" width="95%">
								<tbody>
									<tr>
										<td width="5%"></td>
										<td width="15%">col</td>
										<td>collision data index returned in NDB_NewtonCreateTreeCollision command.</td>
									</tr>
									<tr>
										<td width="5%">&nbsp;</td>
										<td width="15%">(temp vector)</td>
										<td>temp vectors used for passing values (vectors 1-3)</td>
									</tr>
								</tbody></table>
						</font>
					</td>
				</tr>
				<tr>
					<td bgcolor="#dadada"><font face="monospace">returns: nothing.</font></td>
				</tr>
				<tr>
					<td bgcolor="#fafafa">
						<p><b>Comments:</b> This command adds a face to the Tree Collision object.
							&nbsp;Before calling this command, you must place the local location of the 3
							vertices that make up the polygon into temp vectors 1-3. &nbsp;You must have
							called <a href="#NDB_NewtonTreeCollisionBeginBuild">NDB_NewtonTreeCollisionBeginBuild</a>
							before calling this command.</p>
					</td>
				</tr>
			</tbody></table>
		<p><a name="NDB_NewtonTreeCollisionEndBuild"></a></p>
		<table cellspacing="0" bordercolorlight="#0506a5" bordercolordark="#0506a5" bgcolor="#ffffff"
			border="1" width="85%">
			<tbody>
				<tr>
					<td bgcolor="#232323">
						<h3><font color="#fafafa">NDB_NewtonTreeCollisionEndBuild</font></h3>
					</td>
				</tr>
				<tr>
					<td bgcolor="#747ff6"><font color="#ffffff" face="monospace">syntax:
							NDB_NewtonTreeCollisionEndBuild col, flag</font></td>
				</tr>
				<tr>
					<td bgcolor="#fafafa"><font face="monospace">
							<table border="0" width="95%">
								<tbody>
									<tr>
										<td width="5%"></td>
										<td width="15%">col</td>
										<td>collision data index returned in NDB_NewtonCreateTreeCollision command.</td>
									</tr>
									<tr>
										<td width="5%">&nbsp;</td>
										<td width="15%">flag</td>
										<td>optimization flag. 0 = off, 1 = on</td>
									</tr>
								</tbody></table>
						</font>
					</td>
				</tr>
				<tr>
					<td bgcolor="#dadada"><font face="monospace">returns: nothing.</font></td>
				</tr>
				<tr>
					<td bgcolor="#fafafa">
						<p><b>Comments:</b> This command completes a TreeCollision object, making it ready
							to be used by the <a href="#NDB_NewtonCreateBody">NDB_NewtonCreateBody</a> command.
							&nbsp;a flag of "1" tells Newton to optimize the collision data for more
							efficient behavior. &nbsp;This is highly recommended, as optimized objects run
							much faster.</p>
					</td>
				</tr>
			</tbody></table>
		<p>
			<a name="NDB_NewtonCreateTreeCollisionFromSerialization"></a>
		</p>
		<table cellspacing="0" bordercolorlight="#0506a5" bordercolordark="#0506a5" bgcolor="#ffffff"
			border="1" width="85%">
			<tbody>
				<tr>
					<td bgcolor="#232323">
						<h3><font color="#fafafa">NDB_NewtonCreateTreeCollisionFromSerialization</font></h3>
					</td>
				</tr>
				<tr>
					<td bgcolor="#747ff6"><font color="#ffffff" face="monospace">syntax: col =
							NDB_NewtonCreateTreeCollisionFromSerialization( filename )</font></td>
				</tr>
				<tr>
					<td bgcolor="#fafafa"><font face="monospace">
							<table border="0" width="95%">
								<tbody>
									<tr>
										<td width="5%"></td>
										<td width="15%">filename</td>
										<td>file containing serialized TreeCollision data (string)</td>
									</tr>
								</tbody></table>
						</font>
					</td>
				</tr>
				<tr>
					<td bgcolor="#dadada"><font face="monospace">returns: integer index to the collision
							data created.</font></td>
				</tr>
				<tr>
					<td bgcolor="#fafafa"><b>Comments:</b> This command allows the user to load
						previously saved TreeCollision data, instead of creating it from object
						geometry. &nbsp;This is MUCH faster than building tree collision data live.
					</td>
				</tr>
				<tr>
					<td bgcolor="#fafafa">
						<font face="monospace"><b>col = NDB_NewtonCreateTreeCollisionFromSerialization(
								"serial.dat"&nbsp;)</b></font>
					</td>
				</tr>
			</tbody></table>
		<p>
			<a name="NDB_NewtonTreeCollisionSerialize"></a>
		</p>
		<table cellspacing="0" bordercolorlight="#0506a5" bordercolordark="#0506a5" bgcolor="#ffffff"
			border="1" width="85%">
			<tbody>
				<tr>
					<td bgcolor="#232323">
						<h3><font color="#fafafa">NDB_NewtonTreeCollisionSerialize</font></h3>
					</td>
				</tr>
				<tr>
					<td bgcolor="#747ff6"><font color="#ffffff" face="monospace">syntax:
							NDB_NewtonTreeCollisionSerialize col, filename</font></td>
				</tr>
				<tr>
					<td bgcolor="#fafafa"><font face="monospace">
							<table border="0" width="95%">
								<tbody>
									<tr>
										<td width="5%">&nbsp;</td>
										<td width="15%">col</td>
										<td>index to previously created collision data (integer)</td>
									</tr>
									<tr>
										<td width="5%"></td>
										<td width="15%">filename</td>
										<td>file containing serialized TreeCollision data (string)</td>
									</tr>
								</tbody></table>
						</font>
					</td>
				</tr>
				<tr>
					<td bgcolor="#dadada"><font face="monospace">returns: nothing</font></td>
				</tr>
				<tr>
					<td bgcolor="#fafafa"><b>Comments:</b> This command saves a previously built
						TreeCollision into a compiled data file, which can then be loaded at runtim
						with the <a href="#NDB_NewtonCreateTreeCollisionFromSerialization">NDB_NewtonCreateTreeCollisionFromSerialization</a>
						command above..
					</td>
				</tr>
				<tr>
					<td bgcolor="#fafafa">
						<font face="monospace"><b>NDB_NewtonCreateTreeCollisionFromSerialization col,
								"serial.dat"</b></font>
					</td>
				</tr>
			</tbody></table>
		<p><a name="NDB_NewtonReleaseCollision"></a></p>
		<table cellspacing="0" bordercolorlight="#0506a5" bordercolordark="#0506a5" bgcolor="#ffffff"
			border="1" width="85%" ID="Table1">
			<tbody>
				<tr>
					<td bgcolor="#232323">
						<h3><font color="#fafafa">NDB_NewtonReleaseCollision</font></h3>
					</td>
				</tr>
				<tr>
					<td bgcolor="#747ff6"><font color="#ffffff" face="monospace">syntax:
							NDB_NewtonReleaseCollision col</font></td>
				</tr>
				<tr>
					<td bgcolor="#fafafa"><font face="monospace">
							<table border="0" width="95%" ID="Table2">
								<tbody>
									<tr>
										<td width="5%"></td>
										<td width="15%">col</td>
										<td>Release a reference from this collision object returning control to Newton.</td>
									</tr>
								</tbody></table>
						</font>
					</td>
				</tr>
				<tr>
					<td bgcolor="#dadada"><font face="monospace">returns: nothing.</font></td>
				</tr>
				<tr>
					<td bgcolor="#fafafa">
						<p><b>Comments:</b> Collision objects are reference counted objects. The
							application should call <B>NewtonReleaseCollision</B> in order to release
							references to the object. Neglecting to release references to collision
							primitives is a common cause of memory leaks.</p>
					</td>
				</tr>
			</tbody></table>
		<p><a name="NDB_NewtonCreateConvexHullWithScale"></a></p>
		<table cellspacing="0" bordercolorlight="#0506a5" bordercolordark="#0506a5" bgcolor="#ffffff"
			border="1" width="85%" ID="Table3">
			<tbody>
				<tr>
					<td bgcolor="#232323">
						<h3><font color="#fafafa">NDB_NewtonCreateConvexHullWithScale</font></h3>
					</td>
				</tr>
				<tr>
					<td bgcolor="#747ff6"><font color="#ffffff" face="monospace">syntax:
							NDB_NewtonCreateConvexHullWithScale(db_obj)</font></td>
				</tr>
				<tr>
					<td bgcolor="#fafafa"><font face="monospace">
							<table border="0" width="95%" ID="Table4">
								<tbody>
									<tr>
										<td width="5%"></td>
										<td width="15%">Temp Vec 1</td>
										<td>
											<P>Scalar for the convex hull.</P>
										</td>
									</tr>
									<tr>
										<td width="5%"></td>
										<td width="15%">
											db_obj</td>
										<td>
											<P>object to use for convex hull data (integer)</P>
										</td>
									</tr>
								</tbody></table>
						</font>
					</td>
				</tr>
				<tr>
					<td bgcolor="#dadada"><font face="monospace">returns: nothing.</font></td>
				</tr>
				<tr>
					<td bgcolor="#fafafa">
						<p><b>Comments:</b> Uses temp vector 1 as a scalar for the convex hull. use if
							you're scaling your DBPro objects after loading.</p>
					</td>
				</tr>
			</tbody></table>
		<P></P>
		<p><a name="NDB_NewtonCreateTreeCollisionWithScale"></a></p>
		<table cellspacing="0" bordercolorlight="#0506a5" bordercolordark="#0506a5" bgcolor="#ffffff"
			border="1" width="85%" ID="Table5">
			<tbody>
				<tr>
					<td bgcolor="#232323">
						<h3><font color="#fafafa">NDB_NewtonCreateTreeCollisionWithScale</font></h3>
					</td>
				</tr>
				<tr>
					<td bgcolor="#747ff6"><font color="#ffffff" face="monospace">syntax:
							NDB_NewtonCreateTreeCollisionWithScale( [db_num, limb flag] )</font></td>
				</tr>
				<tr>
					<td bgcolor="#fafafa"><font face="monospace">
							<table border="0" width="95%" ID="Table6">
								<tbody>
									<tr>
										<td width="5%"></td>
										<td width="15%">Temp Vec 1</td>
										<td>Scalar for the TreeCollision.</td>
									</tr>
									<tr>
										<td width="5%"></td>
										<td width="15%">
											db_num</td>
										<td>
											<P>Dbpro object number of the object to turn into collision data.</P>
										</td>
									</tr>
									<tr>
										<td width="5%"></td>
										<td width="15%">
											flag</td>
										<td>
											<P>Optional method flag. &nbsp;1 = limb-by-limb method for high poly objects.</P>
										</td>
									</tr>
								</tbody></table>
						</font>
					</td>
				</tr>
				<tr>
					<td bgcolor="#dadada"><font face="monospace">returns: nothing.</font></td>
				</tr>
				<tr>
					<td bgcolor="#fafafa">
						<p><b>Comments:</b> Uses temp vector 1 as a scalar for the TreeCollision. use if
							you're scaling DBPro objects after loading.</p>
					</td>
				</tr>
			</tbody></table>
		<P></P>
		<p><a name="NDB_NewtonCreateTreeCollisionWithScaleUnoptimized"></a></p>
		<table cellspacing="0" bordercolorlight="#0506a5" bordercolordark="#0506a5" bgcolor="#ffffff"
			border="1" width="85%" ID="Table7">
			<tbody>
				<tr>
					<td bgcolor="#232323">
						<h3><font color="#fafafa">NDB_NewtonCreateTreeCollisionWithScaleUnoptimized</font></h3>
					</td>
				</tr>
				<tr>
					<td bgcolor="#747ff6"><font color="#ffffff" face="monospace">syntax:
							NDB_NewtonCreateTreeCollisionWithScaleUnoptimized( [db_num, limb flag] )</font></td>
				</tr>
				<tr>
					<td bgcolor="#fafafa"><font face="monospace">
							<table border="0" width="95%" ID="Table8">
								<tbody>
									<tr>
										<td width="5%"></td>
										<td width="15%">Temp Vec 1</td>
										<td>Scalar for the TreeCollision.</td>
									</tr>
									<tr>
										<td width="5%"></td>
										<td width="15%">
											db_num</td>
										<td>
											<P>Dbpro object number of the object to turn into collision data.</P>
										</td>
									</tr>
									<tr>
										<td width="5%"></td>
										<td width="15%">
											flag</td>
										<td>
											<P>Optional method flag. &nbsp;1 = limb-by-limb method for high poly objects.</P>
										</td>
									</tr>
								</tbody></table>
						</font>
					</td>
				</tr>
				<tr>
					<td bgcolor="#dadada"><font face="monospace">returns: nothing.</font></td>
				</tr>
				<tr>
					<td bgcolor="#fafafa">
						<p><b>Comments:</b> Same as above, but no optimization.</p>
					</td>
				</tr>
			</tbody></table>
		<P></P>
		<p><a name="NDB_NewtonCreateConvexHullModifier"></a></p>
		<table cellspacing="0" bordercolorlight="#0506a5" bordercolordark="#0506a5" bgcolor="#ffffff"
			border="1" width="85%" ID="Table9">
			<tbody>
				<tr>
					<td bgcolor="#232323">
						<h3><font color="#fafafa">NDB_NewtonCreateConvexHullModifier</font></h3>
					</td>
				</tr>
				<tr>
					<td bgcolor="#747ff6"><font color="#ffffff" face="monospace">syntax:
							NDB_NewtonCreateConvexHullModifier( col )</font></td>
				</tr>
				<tr>
					<td bgcolor="#fafafa"><font face="monospace">
							<table border="0" width="95%" ID="Table13">
								<tbody>
									<tr>
										<td width="5%"></td>
										<td width="15%">col</td>
										<td>Collision data index.</td>
									</tr>
								</tbody></table>
						</font>
					</td>
				</tr>
				<tr>
					<td bgcolor="#dadada"><font face="monospace">returns: nothing.</font></td>
				</tr>
				<tr>
					<td bgcolor="#fafafa">
						<p><b>Comments:</b> Makes a copy of an existing collision, which can then be scaled
							in realtime using the commands below. (NDB_NewtonConvexHullModifierSetMatrix
							and NDB_BuildScaleMatrix)</p>
					</td>
				</tr>
			</tbody></table>
		<P></P>
		<p><a name="NDB_NewtonConvexHullModifierSetMatrix"></a></p>
		<table cellspacing="0" bordercolorlight="#0506a5" bordercolordark="#0506a5" bgcolor="#ffffff"
			border="1" width="85%" ID="Table10">
			<tbody>
				<tr>
					<td bgcolor="#232323">
						<h3><font color="#fafafa">NDB_NewtonConvexHullModifierSetMatrix</font></h3>
					</td>
				</tr>
				<tr>
					<td bgcolor="#747ff6"><font color="#ffffff" face="monospace">syntax:
							NDB_NewtonConvexHullModifierSetMatrix( col )</font></td>
				</tr>
				<tr>
					<td bgcolor="#fafafa"><font face="monospace">
							<table border="0" width="95%" ID="Table14">
								<tbody>
									<tr>
										<td width="5%"></td>
										<td width="15%">col</td>
										<td>Collision data index.</td>
									</tr>
								</tbody></table>
						</font>
					</td>
				</tr>
				<tr>
					<td bgcolor="#dadada"><font face="monospace">returns: nothing.</font></td>
				</tr>
				<tr>
					<td bgcolor="#fafafa">
						<p><b>Comments:</b> Sets the scale matrix for the modifier. Use the new
							NDB_BuildScaleMatrix command to build the actual matrix.</p>
					</td>
				</tr>
			</tbody></table>
		<P></P>
		<p><a name="NDB_NewtonConvexHullModifierGetMatrix"></a></p>
		<table cellspacing="0" bordercolorlight="#0506a5" bordercolordark="#0506a5" bgcolor="#ffffff"
			border="1" width="85%" ID="Table11">
			<tbody>
				<tr>
					<td bgcolor="#232323">
						<h3><font color="#fafafa">NDB_NewtonConvexHullModifierGetMatrix</font></h3>
					</td>
				</tr>
				<tr>
					<td bgcolor="#747ff6"><font color="#ffffff" face="monospace">syntax:
							NDB_NewtonConvexHullModifierGetMatrix( col )</font></td>
				</tr>
				<tr>
					<td bgcolor="#fafafa"><font face="monospace">
							<table border="0" width="95%" ID="Table15">
								<tbody>
									<tr>
										<td width="5%"></td>
										<td width="15%">col</td>
										<td>Collision data index.</td>
									</tr>
								</tbody></table>
						</font>
					</td>
				</tr>
				<tr>
					<td bgcolor="#dadada"><font face="monospace">returns: nothing.</font></td>
				</tr>
				<tr>
					<td bgcolor="#fafafa">
						<p><b>Comments:</b> Fills temp matrix with the current scale matrix for the
							collision.</p>
					</td>
				</tr>
			</tbody></table>
		<P></P>
		<p><a name="NDB_BuildScaleMatrix"></a></p>
		<table cellspacing="0" bordercolorlight="#0506a5" bordercolordark="#0506a5" bgcolor="#ffffff"
			border="1" width="85%" ID="Table12">
			<tbody>
				<tr>
					<td bgcolor="#232323">
						<h3><font color="#fafafa">NDB_BuildScaleMatrix</font></h3>
					</td>
				</tr>
				<tr>
					<td bgcolor="#747ff6"><font color="#ffffff" face="monospace">syntax:
							NDB_BuildScaleMatrix&nbsp;sx, sy, sz</font></td>
				</tr>
				<tr>
					<td bgcolor="#fafafa"><font face="monospace">
							<table border="0" width="95%" ID="Table16">
								<tbody>
									<tr>
										<td width="5%"></td>
										<td width="15%">sx,sy,sz</td>
										<td>Scale matrix values (float).</td>
									</tr>
								</tbody></table>
						</font>
					</td>
				</tr>
				<tr>
					<td bgcolor="#dadada"><font face="monospace">returns: nothing.</font></td>
				</tr>
				<tr>
					<td bgcolor="#fafafa">
						<p><b>Comments:</b> Builds a simple scale matrix, for use with the above commands.</p>
					</td>
				</tr>
			</tbody></table>
		<P></P>
		<p><a name="NDB_NewtonConvexCollisionCalculateInertialMatrix"></a></p>
		<table cellspacing="0" bordercolorlight="#0506a5" bordercolordark="#0506a5" bgcolor="#ffffff"
			border="1" width="85%">
			<tr>
				<td bgcolor="#232323">
					<h3><font color="#fafafa">NDB_NewtonConvexCollisionCalculateInertialMatrix</font></h3>
				</td>
			</tr>
			<tr>
				<td bgcolor="#747ff6"><font color="#ffffff" face="monospace">syntax:
						NDB_NewtonConvexCollisionCalculateInertialMatrix col</font></td>
			</tr>
			<tr>
				<td bgcolor="#fafafa"><font face="monospace">
						<table border="0" width="95%">
							<tr>
								<td width="5%"></td>
								<td width="15%">col</td>
								<td>
									<p>index of collision data to calculate IM</p>
								</td>
							</tr>
							<tr>
								<td width="5%"></td>
								<td width="15%">(vector 1)</td>
								<td>
									<p>principal inertia</p>
								</td>
							</tr>
							<tr>
								<td width="5%"></td>
								<td width="15%">(vector 2)</td>
								<td>
									<p>center of mass</p>
								</td>
							</tr>
						</table>
					</font>
				</td>
			</tr>
			<tr>
				<td bgcolor="#dadada"><font face="monospace">returns: nothing.</font></td>
			</tr>
			<tr>
				<td bgcolor="#fafafa">
					<p>Calculate the three principal axis and the the values of the inertia matrix of a convex collision objects.</p>
					<p><b>Comments:</b><br>Fills <b>temp vector 1</b> with the values of the principal inertia for this collision.<br>
					Fills <b>temp vector 2</b> with the values of the center of mass for this collision.</p>
				</td>
			</tr>
		</table>
		<p><a name="NDB_NewtonConvexCollisionCalculateVolume"></a></p>
		<table cellspacing="0" bordercolorlight="#0506a5" bordercolordark="#0506a5" bgcolor="#ffffff"
			border="1" width="85%">
			<tr>
				<td bgcolor="#232323">
					<h3><font color="#fafafa">NDB_NewtonConvexCollisionCalculateVolume</font></h3>
				</td>
			</tr>
			<tr>
				<td bgcolor="#747ff6"><font color="#ffffff" face="monospace">syntax:
						vol = NDB_NewtonConvexCollisionCalculateVolume( col )</font></td>
			</tr>
			<tr>
				<td bgcolor="#fafafa"><font face="monospace">
						<table border="0" width="95%">
							<tr>
								<td width="5%"></td>
								<td width="15%">col</td>
								<td>
									<p>index of collision data to calculate volume</p>
								</td>
							</tr>
						</table>
					</font>
				</td>
			</tr>
			<tr>
				<td bgcolor="#dadada"><font face="monospace">returns: collision geometry volume (float). This function will return zero if the body collision geometry is not convex.</font></td>
			</tr>
			<tr>
				<td bgcolor="#fafafa">
					<p><b>Remarks:</b><br>
					   The total volume calculated by the function is only an approximation of the ideal volume. This is not an error, it is a fact resulting from the polygonal representation of convex solids.
                       This function can be used to assist the application in calibrating features like fluid density weigh factor when calibrating buoyancy forces for more realistic result.</p>
				</td>
			</tr>
		</table>
	</body>
</html>
